const uniID = require('uni-id-common') // 引入uni-id-common
const db = uniCloud.database(); // 引入数据库
const getPublicData = uniCloud.importObject('get-public-data'); // 引入获取公共数据
const UniSecCheck = require('uni-sec-check'); // 引入uni-sec-check内容安全公共模块
const contentSafeErrCode = {
	'uni-sec-check-system-error': '系统错误',
	'uni-sec-check-risk-content': '存在风险内容',
	'uni-sec-check-invalid-appid': 'appid错误',
	'uni-sec-check-invalid-appsecret': 'appsecret错误',
	'uni-sec-check-invalid-access-token': 'access_token错误',
	'uni-sec-check-access-token-expired': '登录状态过期',
	'uni-sec-check-invalid-file-type': '错误的文件类型',
	'uni-sec-check-invalid-image-size': '图片大小超出限制',
	'uni-sec-check-invalid-request-url': '请求url错误',
	'uni-sec-check-invalid-request-param': '请求参数错误',
	'uni-sec-check-invalid-request-format': '请求格式错误',
	'uni-sec-check-param-required': '缺少必要参数',
	'uni-sec-check-empty-image': '图片为空',
	'uni-sec-check-empty-content': '内容为空',
	'uni-sec-check-invoke-out-of-limit': '调用次数超出限制'
}

// 唯一订单号生成函数
function generateOrderNumber() {
	const timestamp = Date.now(); // 获取毫秒级时间戳
	const randomNum = Math.floor(Math.random() * 1000000); // 6位随机数
	return `QMY${timestamp}${randomNum}`;
}

module.exports = {
	_before: async function() { // 通用预处理器
		const methodName = this.getMethodName(); // 获取当前调用的方法名
		const params = this.getParams(); // 获取当前参数列表
		const requestId = this.getUniCloudRequestId(); // 获取请求id
		const cloudInfo = this.getCloudInfo(); // 获取云端信息
		this.clientInfo = this.getClientInfo(); // 获取客户端信息
		this.uniIDIns = await uniID.createInstance({ // 创建uni-id实例
			context: cloudInfo
		});
		this.token = await this.getUniIdToken(); // 获取用户token
		if (!this.token) {
			const error = new Error('用户未登录');
			error.code = 401; // 自定义错误码
			error.msg = '用户未登录'; // 自定义错误信息
			throw error;
		}
		this.userInfo = await this.uniIDIns.checkToken(this.token); // 获取用户信息
		if (this.userInfo.code == 30203 || !this.userInfo.uid) {
			const error = new Error('登录状态过期');
			error.code = 401; // 自定义错误码
			error.msg = '登录状态过期'; // 自定义错误信息
			throw error;
		}
		// 检查调用的是否是评论等涉及内容安全的方法(只有微信小程序端有效)
		if (['commentCircle', 'replyComment', 'addCircleData', 'addActivityData', 'addNoticeData',
				'addCertificationApplication'
			].includes(methodName)) {
			// 获取当前用户openid
			const openid = await db.collection('uni-id-users').doc(this.userInfo.uid).field({
				wx_openid: true
			}).get();
			if (openid.data[0].wx_openid.mp) {
				// 初始化实例
				const uniSecCheck = new UniSecCheck({
					provider: 'mp-weixin',
					requestId: this
						.getUniCloudRequestId(), // 云函数内则写 context.requestId 云对象内则写 this.getUniCloudRequestId()
				});
				const checkTextRes = await uniSecCheck.textSecCheck({
					content: methodName == 'commentCircle' ? params[1] : methodName == 'replyComment' ?
						params[2] : methodName == 'addCircleData' ? params[0] + params[1] :
						methodName ==
						'addActivityData' ? params[0].title + params[0].content : methodName ==
						'addNoticeData' ? params[0].title + params[0].content : methodName ==
						'addCertificationApplication' ? params[0].name + params[0].idNumber + params[0]
						.phone + params[0].address + params[0].reason : '', // 文本内容，不可超过500KB
					openid: openid.data[0].wx_openid.mp,
					version: 2, // 接口版本号
				});
				if (checkTextRes.errCode != 0) {
					const error = new Error(contentSafeErrCode[checkTextRes.errCode]);
					error.code = 403;
					error.msg = contentSafeErrCode[checkTextRes.errCode];
					throw error;
				}
				if (checkTextRes.result.suggest != 'pass') {
					const error = new Error(`内容存在${checkTextRes.result.label}信息`);
					error.code = 403;
					error.msg = `内容存在${checkTextRes.result.label}信息`;
					throw error;
				}
				if (methodName == 'addCircleData' || methodName == 'addActivityData' || methodName ==
					'addCertificationApplication') {
					// 检查图片内容
					const checkImgRes = await uniSecCheck.imgSecCheck({
						image: methodName == 'addCircleData' ? params[0].imgs[0].url : methodName ==
							'addActivityData' ? params[0].imgUrl[0].url : methodName ==
							'addCertificationApplication' ? params[0].idFront[0].url : '', // 图片文件url
						openid: openid.data[0].wx_openid.mp,
						version: 2 // 接口版本号
					});
					if (checkImgRes.errCode != 0) {
						const error = new Error(contentSafeErrCode[checkImgRes.errCode]);
						error.code = 403;
						error.msg = contentSafeErrCode[checkImgRes.errCode];
						throw error;
					}
				}
			}
		}
		// console.log('User Data:', JSON.stringify(this.userInfo, null, 2)); // 更清晰地打印对象
	},
	/**
	 * 新增报名数据
	 * @param {string} activity_id:活动id
	 * @returns {object} 返回报名成功状态
	 */
	async signUp(activity_id) {
		// 判断参数是否为空
		if (!activity_id) {
			throw new Error('参数不能为空');
		}
		//判断活动是否存在
		const activity = await getPublicData.getActivityDetail(activity_id);
		if (!activity.data.length) {
			throw new Error('活动不存在');
		}
		//判断活动是否已结束
		if (activity.data[0].signup_end_time < new Date()) {
			throw new Error('报名已截止');
		}
		// 当前时间小于报名时间，活动未开始
		if (new Date() < activity.data[0].signup_start_time) {
			throw new Error('报名未开始');
		}
		// 判断活动是否已满
		const signupCount = await db.collection('qmy-activity-sign-up').where({
			activity_id: activity_id,
			signup_status: 0
		}).count();
		if (signupCount >= activity.data[0].people_num) {
			throw new Error('活动名额已满');
		}
		// 判断活动是否审核通过
		if (activity.data[0].audit_status !== 1) {
			throw new Error('活动未审核');
		}
		// 判断用户是否已报名
		const signup = await db.collection('qmy-activity-sign-up').where({
			activity_id: activity_id,
			user_id: this.userInfo.uid
		}).get();
		if (signup.data.length && signup.data[0].signup_status == 0) {
			throw new Error('您已报名');
		}
		//查询用户表，看用户信息是否含有联系人姓名和联系电话
		const user = await db.collection('uni-id-users').where({
			_id: this.userInfo.uid
		}).get();
		const error = new Error('请先完善联系方式');
		error.code = 400;
		error.msg = '请先完善联系方式';
		if (!user.data[0].mobile) {
			throw error;
		}
		// 如何是付费活动
		if (activity.data[0].is_pay) {
			const error = new Error('付费活动请先支付');
			error.code = 500;
			error.msg = '付费活动请先支付';
			throw error;
		} else {
			let res = [];
			// 如果用户已经报名过此活动不过取消报名，再次报名时更新，而不是新增
			if (signup.data.length) {
				res = await db.collection('qmy-activity-sign-up').where({
					_id: signup.data[0]._id
				}).update({
					signup_status: 0,
					signup_time: Date.now()
				});
			} else {
				// 保存报名数据
				res = await db.collection('qmy-activity-sign-up').add({
					user_id: this.userInfo.uid,
					activity_id: activity_id,
					signup_status: 0,
					signup_time: Date.now()
				});
			}
			return {
				code: 200,
				data: res.data,
				msg: '报名成功'
			}
		}

	},
	/**
	 * 点赞、取消点赞圈子
	 * @param {string} id:圈子id
	 * @returns {object} 返回点赞状态
	 */
	async likeCircle(id) {
		// 判断是否已点赞
		const like = await db.collection('qmy-article-like').where({
			article_id: id,
			user_id: this.userInfo.uid
		}).get();
		// 判断圈子是否存在
		const circle = await db.collection('uni-cms-articles').where({
			_id: id
		}).get();
		if (!circle.data.length) {
			throw new Error('圈子不存在');
		}
		if (like.data.length) {
			// 取消点赞
			await db.collection('qmy-article-like').where({
				_id: like.data[0]._id
			}).remove();
			return {
				code: 200,
				msg: '取消点赞成功'
			}
		} else {
			// 点赞
			await db.collection('qmy-article-like').add({
				article_id: id,
				user_id: this.userInfo.uid,
				type: 0,
				like_read_status: 0,
				create_date: Date.now()
			});
			return {
				code: 200,
				msg: '点赞成功'
			}
		}
	},
	/**
	 * 评论圈子
	 * @param {string} id:圈子id
	 * @param {string} comment:评论内容
	 * @returns {object} 返回评论状态
	 */
	async commentCircle(id, comment) {
		// 判断评论内容是否为空
		if (!comment) {
			throw new Error('评论内容不能为空');
		}
		// 判断圈子是否存在
		const circle = await db.collection('uni-cms-articles').where({
			_id: id
		}).get();
		if (!circle.data.length) {
			throw new Error('圈子不存在');
		}
		// 判断圈子是否开启评论
		if (circle.data[0].comment_status !== 1) {
			throw new Error('此圈子不允许评论');
		}
		// 保存评论
		await db.collection('opendb-news-comments').add({
			article_id: id,
			user_id: this.userInfo.uid,
			comment_content: comment,
			comment_type: 0,
			like_read_status: 0,
			create_date: Date.now(),
			comment_ip: this.clientInfo?.clientIP || '127.0.0.1',
		});
		return {
			code: 200,
			msg: '评论成功'
		}
	},
	/**
	 * 点赞评论
	 * @param {string} id:评论id
	 * @returns {object} 返回点赞状态
	 */
	async likeComment(id) {
		// 判断是否已点赞
		const like = await db.collection('qmy-article-like').where({
			comment_id: id, // 评论id
			user_id: this.userInfo.uid, // 用户id
			type: 1, // 1表示评论点赞
		}).get();
		// 判断评论是否存在
		const comment = await db.collection('opendb-news-comments').where({
			_id: id
		}).get();
		if (!comment.data.length) {
			throw new Error('评论不存在');
		}
		if (like.data.length) {
			// 取消点赞
			await db.collection('qmy-article-like').where({
				_id: like.data[0]._id
			}).remove();
			return {
				code: 200,
				msg: '取消点赞成功'
			}
		} else {
			// 点赞
			await db.collection('qmy-article-like').add({
				comment_id: id,
				user_id: this.userInfo.uid,
				type: 1, // 1表示评论点赞
				like_read_status: 0,
				create_date: Date.now()
			});
			return {
				code: 200,
				msg: '点赞成功'
			}
		}
	},
	/**
	 * 回复评论
	 * @param {string} id:评论id
	 * @param {string} comment:评论内容
	 * @returns {object} 返回回复状态
	 */
	async replyComment(circleId, id, comment, superlativeId) {
		// 判断评论内容是否为空
		if (!comment) {
			throw new Error('评论内容不能为空');
		}
		// 判断评论是否存在
		const comments = await db.collection('opendb-news-comments').doc(id).get();
		if (!comments.data.length) {
			throw new Error('评论不存在');
		}
		// 保存回复
		await db.collection('opendb-news-comments').add({
			superlative_comment_id: superlativeId,
			article_id: circleId,
			comment_id: id,
			user_id: this.userInfo.uid,
			comment_content: comment,
			reply_user_id: comments.data[0].user_id,
			reply_comment_id: comments.data[0]._id,
			comment_type: 1,
			create_date: Date.now(),
			comment_ip: this.clientInfo?.clientIP || '127.0.0.1',
		});
		return {
			code: 200,
			msg: '回复成功'
		}
	},
	/**
	 * 发布圈子
	 * @param {string} title:标题
	 * @param {string} content:内容
	 * @param {string} activityId:活动id
	 * @param {array} imgs:图片
	 * @returns {object} 返回发布状态
	 */
	async addCircleData(data) {
		if (!data.title) {
			throw new Error('标题不能为空');
		}
		if (!data.content) {
			throw new Error('内容不能为空');
		}
		if (!data.imgs) {
			throw new Error('图片不能为空');
		}
		// 判断图片是否大于6张
		if (data.imgs.length > 6) {
			throw new Error('图片不能大于6张');
		}
		// 判断标题是否大于23个字
		if (data.title.length > 23) {
			throw new Error('标题不能大于23个字符');
		}
		// 取出每个imgs里的url
		const imgs = data.imgs.map(item => item.url);
		// 保存数据
		await db.collection('uni-cms-articles').add({
			user_id: this.userInfo.uid,
			activity_id: data.activityId,
			title: data.title,
			content: data.content,
			article_status: 1,
			is_sticky: false,
			is_essence: false,
			comment_status: 1,
			imgs_info: data.imgs, //适配圈子修改时读取用
			thumbnail: imgs,
			publish_date: Date.now(),
			publish_ip: this.clientInfo?.clientIP || '127.0.0.1',
			last_modify_date: Date.now(),
			last_modify_ip: this.clientInfo?.clientIP || '127.0.0.1',
			audit_status: 0,
		});
		return {
			code: 200,
			msg: '发布成功，等待审核通过后展示'
		}
	},
	/**
	 * 发布活动
	 * @param {string} data:活动数据
	 * @returns {object} 返回发布状态
	 */
	async addActivityData(data) {
		// 判断是否是组织者
		const userInfo = await db.collection('uni-id-users').where({
			_id: this.userInfo.uid
		}).field({
			role: true
		}).get();
		if (!userInfo?.data[0]?.role?.includes('organizer')) {
			let error = new Error('您还没有权限编辑活动，快去认证吧');
			error.code = 500;
			error.msg = '您还没有权限编辑活动，快去认证吧';
			throw error;
		}
		if (!data.title) {
			throw new Error('标题不能为空');
		}
		if (!data.content) {
			throw new Error('内容不能为空');
		}
		if (!data.imgUrl) {
			throw new Error('图片不能为空');
		}
		if (data.imgUrl.length > 6) {
			throw new Error('图片不能大于6张');
		}
		if (!data.activityType) {
			throw new Error('活动分类不能为空');
		}
		if (!data.signUpSTime) {
			throw new Error('报名开始时间不能为空');
		}
		if (!data.signUpETime) {
			throw new Error('报名结束时间不能为空');
		}
		if (!data.activitySTime) {
			throw new Error('活动开始时间不能为空');
		}
		if (!data.activityETime) {
			throw new Error('活动结束时间不能为空');
		}
		if (!data.latitude) {
			throw new Error('经度不能为空');
		}
		if (!data.longitude) {
			throw new Error('纬度不能为空');
		}
		if (!data.activityLocation) {
			throw new Error('活动地点不能为空');
		}
		if (!data.activityPeople) {
			throw new Error('活动人数不能为空');
		}
		if (data.activityIsPay) {
			// 如果活动是否付费为true，检查付费金额是否为整数
			const payIsInteger = /^[0-9]+$/.test(data.activityPay);
			if (!payIsInteger || Number(data.activityPay) <= 0) {
				throw new Error('付费金额必须为整数');
			}
		}

		// 转换报名时间和活动时间为时间戳
		const signUpSTime = new Date(data.signUpSTime).getTime(); // 报名开始时间
		const signUpETime = new Date(data.signUpETime).getTime(); // 报名结束时间
		const activitySTime = new Date(data.activitySTime).getTime(); // 活动开始时间
		const activityETime = new Date(data.activityETime).getTime(); // 活动结束时间
		const activityPeople = parseInt(data.activityPeople); // 活动人数
		const activityPay = parseFloat(data.activityPay || 0); // 付费金额
		// 如果报名开始时间大于报名结束时间
		if (signUpSTime > signUpETime) {
			throw new Error('报名开始时间不能大于报名结束时间');
		}
		// 如果活动开始时间大于活动结束时间
		if (activitySTime > activityETime) {
			throw new Error('活动开始时间不能大于活动结束时间');
		}
		// 如果活动开始时间小于报名结束时间
		if (activitySTime < signUpETime) {
			throw new Error('活动开始时间不能小于报名结束时间');
		}
		// 检查活动人数是否为整数
		const peopleIsInteger = /^[0-9]+$/.test(data.activityPeople);
		if (!peopleIsInteger || Number(data.activityPeople) <= 0) {
			throw new Error('活动人数不能为负数');
		}
		// 查看此用户的用户信息检查是否存在联系方式
		const user = await db.collection('uni-id-users').where({
			_id: this.userInfo.uid
		}).get();
		if (!user.data[0].mobile) {
			const error = new Error('请先完善联系方式');
			error.code = 400;
			error.msg = '请先完善联系方式';
			throw error;
		}
		// 往图片数组里加入src，值为url的值,异步用for()
		for (let i = 0; i < data.imgUrl.length; i++) {
			data.imgUrl[i].src = data.imgUrl[i].url;
		}
		// 如果社群二维码不为空，则为社群二维码数组里的每条加上src
		if (data.groupCodeImg.length) {
			for (let i = 0; i < data.groupCodeImg.length; i++) {
				data.groupCodeImg[i].src = data.groupCodeImg[i].url;
			}
		}
		// 保存活动数据
		await db.collection('qmy-activity').add({
			name: data.title,
			content: data.content,
			imgs: data.imgUrl,
			tags: data.activityTag,
			type: data.activityType,
			signup_start_time: signUpSTime,
			signup_end_time: signUpETime,
			start_time: activitySTime,
			end_time: activityETime,
			location: data.activityLocation,
			location_lat: String(data.latitude),
			location_lng: String(data.longitude),
			is_pay: data.activityIsPay,
			pay_amount: activityPay,
			people_num: activityPeople,
			group_qrcode: data.groupCodeImg,
			user_id: this.userInfo.uid,
			is_recommend: false,
			audit_status: 0,
			create_time: Date.now(),
		});
		return {
			code: 200,
			msg: '发布成功，等待审核通过后展示'
		}
	},
	/**
	 * 发布通知
	 * @param {string} data:通知数据
	 * @param {string} activityId:活动id
	 * @param {string} content:内容
	 * @param {string} title:标题
	 * @returns {object} 返回发布状态
	 */
	async addNoticeData(data) {
		// 判断是否是组织者
		const userInfo = await db.collection('uni-id-users').where({
			_id: this.userInfo.uid
		}).field({
			role: true
		}).get();
		if (!userInfo?.data[0]?.role?.includes('organizer')) {
			throw new Error('您还没有权限发布通知，快去认证吧');
		}
		if (!data.title) {
			throw new Error('标题不能为空');
		}
		if (!data.content) {
			throw new Error('内容不能为空');
		}
		if (!data.activityId) {
			throw new Error('活动不能为空');
		}

		// 判断选择的是否是自己的活动
		const myActivity = await db.collection('qmy-activity').where({
			_id: data.activityId,
			user_id: this.userInfo.uid
		}).get();
		// 判断活动是否审核通过
		if (myActivity.data[0].audit_status !== 1) {
			throw new Error('活动未审核通过');
		}
		if (!myActivity.data.length) {
			throw new Error('不能选择别人的活动');
		}

		// 保存通知数据
		await db.collection('qmy-notice').add({
			notice_type: 1,
			notice_title: data.title,
			notice_content: data.content,
			activity_id: data.activityId,
			user_id: this.userInfo.uid,
			user_read_status_array: [],
			activity_audit_status: 0,
			notice_time: Date.now(),
		});
		return {
			code: 200,
			msg: '发布成功，等待审核通过后展示'
		}
	},
	/**
	 * 添加认证申请
	 * @param {string} data:认证申请数据
	 * @returns {object} 返回认证申请状态
	 */
	async addCertificationApplication(data) {
		// 校验参数
		if (!data.idFront) {
			throw new Error('身份证正面照片不能为空');
		}
		if (!data.idBack) {
			throw new Error('身份证反面照片不能为空');
		}
		if (!data.name) {
			throw new Error('真实姓名不能为空');
		}
		if (!data.idNumber) {
			throw new Error('身份证号不能为空');
		}
		if (!data.phone) {
			throw new Error('联系电话不能为空');
		}
		if (!data.address) {
			throw new Error('联系地址不能为空');
		}
		if (!data.reason) {
			throw new Error('申请理由不能为空');
		}
		// 判断该用户是否已认证或存在审核中的数据
		const certification = await db.collection('qmy-certification-application').where({
			user_id: this.userInfo.uid,
			apply_status: db.command.lt(2) //0审核中，1审核通过，2审核不通过
		}).get();
		// 查询此用户是否拥有组织者角色
		const user = await db.collection('uni-id-users').where({
			_id: this.userInfo.uid
		}).get();
		if (user.data[0]?.role?.includes('organizer')) {
			throw new Error('您已是活动组织者，无需再次认证');
		}
		if (certification.data.length) {
			if (certification.data[0].apply_status === 0) {
				throw new Error('请勿重复提交，耐心等待审核结果');
			} else if (certification.data[0].apply_status === 1) {
				throw new Error('您已认证成功，请勿重复提交');
			}
		}
		// 保存认证申请数据
		await db.collection('qmy-certification-application').add({
			user_id: this.userInfo.uid,
			id_front: data.idFront,
			id_back: data.idBack,
			real_name: data.name,
			id_number: data.idNumber,
			contact_phone: data.phone,
			contact_address: data.address,
			reason: data.reason,
			apply_status: 0,
			create_time: Date.now(),
		});
		return {
			code: 200,
			msg: '提交成功，请耐心等待审核'
		}
	},
	/**
	 * 创建报名订单
	 * @param {string} data:报名数据
	 * @returns {object} 返回报名订单
	 */
	async signUpCreateOrder(data) {
		// 当前时间
		const currentTime = Date.now();
		// 查询用户余额
		const userBalance = await db.collection('qmy-user-wallet').where({ user_id: this.userInfo.uid }).orderBy('create_date', 'desc').limit(1).get();
		// 查询活动的实际付费金额
		const activity = await db.collection('qmy-activity').doc(data.custom.activity_id).get();
		// 如果活动不存在
		if (!activity.data[0]) {
			throw new Error('活动不存在');
		}
		// 判断当前时间是否在活动报名时间内
		if (currentTime < activity.data[0].signup_start_time || currentTime > activity.data[0].signup_end_time) {
			throw new Error('当前时间不在活动报名时间内');
		}
		// 判断活动是否审核通过
		if (activity.data[0].audit_status != 1) {
			throw new Error('当前活动未审核');
		}
		// 判断是否已经报名
		const signup = await db.collection('qmy-activity-sign-up').where({
			activity_id: activity.data[0]._id,
			user_id: this.userInfo.uid
		}).get();
		if (signup.data.length && signup.data[0].signup_status == 0) {
			throw new Error('您已报名，请勿重复报名');
		}
		// 判断用户是否存在联系方式
		const user = await db.collection('uni-id-users').doc(this.userInfo.uid).get();
		if (!user.data[0].mobile) {
			throw new Error('请完善联系方式');
		}
		// 如果用户余额小于活动实际付费金额
		if (userBalance.data[0].balance < activity.data[0].pay_amount) {
			throw new Error('余额不足,请先充值');
		}

		// 生成唯一订单号
		const orderNumber = generateOrderNumber();
		// 生成插件订单号
		const pluginOrderNumber = generateOrderNumber() + '-1';
		// 需要扣除的余额
		const deductBalance = userBalance.data[0].balance - activity.data[0].pay_amount;
		// 新增余额变动记录，扣除用户余额
		await db.collection('qmy-user-wallet').add({
			user_id: this.userInfo.uid,
			money: activity.data[0].pay_amount,
			type: 2,
			balance: deductBalance,
			comment: `活动报名`,
			create_date: Date.now()
		});
		// 创建订单
		await db.collection('uni-pay-orders').add({
			provider: 'wallet', // 支付方式
			provider_pay_type: 'balance', // 支付类型
			uni_platform: 'mp-weixin', // 平台
			status: 1, // 订单状态
			type: 'sign-up', // 订单类型
			order_no: orderNumber, // 订单号
			out_trade_no: pluginOrderNumber, // 插件订单号
			user_id: this.userInfo.uid, // 用户id
			nickname: user.data[0].nickname, // 用户昵称
			device_id: this.clientInfo?.deviceId || '', // 设备id
			client_ip: this.clientInfo?.clientIP || '127.0.0.1', // 客户端ip
			openid: user.data[0].wx_openid?.mp || '', // 用户openid
			description: activity.data[0].name + '活动的报名费用', // 订单描述
			total_fee: activity.data[0].pay_amount, // 订单金额
			refund_fee: 0, // 退款金额
			refund_count: 0, // 退款次数
			appid: this.clientInfo?.appId || '', // 应用id
			custom: {
				activity_id: activity.data[0]._id, // 活动id
			},
			create_date: Date.now(), // 创建时间
			stat_data: {
				platform: 'mp-weixin', // 平台
				app_version: this.clientInfo?.appVersion || '', // 应用版本
				app_version_code: this.clientInfo?.appVersionCode || '', // 应用版本码
				os: this.clientInfo?.osName || '', // 操作系统
				channel: this.clientInfo?.osVersion || '', // 操作系统版本
				scene: this.clientInfo?.hostVersion || '', // 场景
			},
			pay_date: Date.now(), // 支付时间
			user_order_success: true
		});
		let signupRes = [];
		// 校验通过，新增报名数据，如果用户已经报名过此活动不过取消报名，再次报名时更新，而不是新增
		if (signup.data.length) {
			signupRes = await db.collection('qmy-activity-sign-up').where({
				_id: signup.data[0]._id
			}).update({
				signup_amount: activity.data[0].pay_amount, // 报名金额
				order_id: pluginOrderNumber, // 订单号
				signup_status: 0,
				signup_time: Date.now()
			});
		} else {
			signupRes = await db.collection('qmy-activity-sign-up').add({
				user_id: this.userInfo.uid, // 用户id
				activity_id: activity.data[0]._id, // 活动id
				signup_amount: activity.data[0].pay_amount, // 报名金额
				order_id: pluginOrderNumber, // 订单号
				signup_status: 0, // 报名状态
				signup_time: Date.now() // 报名时间
			});
		}
		return {
			code: 200,
			msg: '报名成功'
		}
	}
}